home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / seyon / SeSet.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-03  |  14.0 KB  |  689 lines
  1.  
  2.  
  3. /*
  4.  * This file is part of the Seyon, Copyright (c) 1992-1993 by Muhammad M.
  5.  * Saggaf. All rights reserved.
  6.  *
  7.  * See the file COPYING (1-COPYING) or the manual page seyon(1) for a full
  8.  * statement of rights and permissions for this program.
  9. */
  10.  
  11. #include <math.h>
  12.  
  13. #include <X11/Intrinsic.h>
  14. #include <X11/StringDefs.h>
  15.  
  16. #include <X11/Xaw/Toggle.h>
  17. #include <X11/Xaw/Dialog.h>
  18.  
  19. #include "seyon.h"
  20. #include "SeDecl.h"
  21.  
  22. extern int      param_pipe[2];
  23.  
  24. int             DetNewlineTrMode(),
  25.                 ToggleNewlineMode(),
  26.                 SetIStrip(),
  27.                 ToggleDelMode(),
  28.                 ToggleMetaKeyTr(),
  29.                 ToggleXOffMode(),
  30.                 ToggleRtsctsMode(),
  31.                 ToggleZmodemAutoDownload(),
  32.                 ToggleIdleGuard(),
  33.                 MenuSetGetBaud(),
  34.                 MenuSetGetCSize(),
  35.                 MenuSetGetParity(),
  36.                 MenuSetGetStopBits(),
  37.                 MenuSetGetParamSCut(),
  38.                 MenuSetGetNewlineTrMode();
  39. void            UpdateToggleSettings(),
  40.                 UpdateStates(),
  41.                 SetGetRadioVal(),
  42.                 SetDoGetRadioVal(),
  43.                 SetGetValue(),
  44.                 SetDoGetValue();
  45. int             SetBaud(),
  46.                 SetPort();
  47.  
  48. int             newlineTrMode;
  49.  
  50. struct _setToggle {
  51.   Widget          widget;
  52.   char           *name;
  53.   int             state;
  54.   int            (*call_back)();
  55. };
  56.  
  57. struct _setRadio {
  58.   String          name;
  59.   String          button[10];
  60.   int             activeIndex;
  61.   int             (*call_back)();
  62. };
  63.  
  64. struct _setValue {
  65.   char           *name;
  66.   char            value[SM_BUF];
  67.                   int(*call_back)();
  68. };
  69.  
  70. static struct _setToggle set_toggle[] =
  71. {
  72.   {NULL, "stripHighBit", 0, SetIStrip},
  73.   {NULL, "del", 0, ToggleDelMode},
  74.   {NULL, "meta_tr", 0, ToggleMetaKeyTr},
  75.   {NULL, "xoff", 0, ToggleXOffMode},
  76.   {NULL, "rtscts", 0, ToggleRtsctsMode},
  77.   {NULL, "autozm", 0, ToggleZmodemAutoDownload},
  78.   {NULL, "idle", 0, ToggleIdleGuard},
  79.   {NULL, NULL, 0, NULL}
  80. };
  81.  
  82. static struct _setRadio setRadio[] =
  83. {
  84.   {"baud", {"300", "1200", "2400", "4800", "9600", "19200", "38400",
  85. #if USE_NONSTD_BAUD
  86.     "57600", "115200",
  87. #endif
  88.     NULL}, 1, MenuSetGetBaud},
  89.   {"bits", {"5", "6", "7", "8", NULL}, 1, MenuSetGetCSize},
  90.   {"parity", {"none", "odd", "even", NULL}, 1, MenuSetGetParity},
  91.   {"stopBits", {"1", "2", NULL}, 1, MenuSetGetStopBits},
  92.   {"cut", {"8n1", "7e1", "other", NULL}, 1, MenuSetGetParamSCut},
  93.   {"nl_tr", {"nl", "cr", "cr_lf", NULL}, 1, MenuSetGetNewlineTrMode},
  94.   {NULL, {NULL}, 0, NULL}
  95. };
  96.  
  97. static struct _setValue set_value[] =
  98. {
  99.   {"port", "", SetPort},
  100.   {NULL, "", NULL}
  101. };
  102.  
  103. struct _setRadio *curRadObjPtr;
  104. struct _setValue *curValObjPtr;
  105.  
  106. void
  107. TopSet(w)
  108.      Widget          w;
  109. {
  110.   Widget          popup,
  111.                   mBox,
  112.                   uBox,
  113.                   lBox;
  114.   struct _setToggle *tptr;
  115.   struct _setRadio *rPtr;
  116.   struct _setValue *vptr;
  117.  
  118.   ErrorIfBusy()
  119.  
  120.   tptr = set_toggle;
  121.   tptr->state = qres.stripHighBit; tptr++;
  122.   tptr->state = qres.backspaceTranslation; tptr++;
  123.   tptr->state = qres.metaKeyTranslation; tptr++;
  124.   tptr->state = qres.xonxoffFlowControl; tptr++;
  125.   tptr->state = qres.rtsctsFlowControl; tptr++;
  126.   tptr->state = qres.autoZmodem; tptr++;
  127.   tptr->state = qres.idleGuard; tptr++;
  128.  
  129.   popup = SeAddPopup("set", w);
  130.   mBox = AddPaned("mBox", popup);
  131.   uBox = AddBox("uBox", mBox);
  132.   lBox = AddBox("lBox", mBox);
  133.  
  134.   for (tptr = set_toggle; tptr->name != NULL; tptr++) {
  135.     tptr->widget = SeAddToggleWCD(tptr->name, uBox, UpdateToggleSettings,
  136.                                   (XtPointer)(tptr->call_back));
  137.     SeSetUnsetToggle(tptr->widget, tptr->state);
  138.   }
  139.  
  140.   for (rPtr = setRadio; rPtr->name != NULL; rPtr++)
  141.     SeAddButtonWCD(rPtr->name, uBox, SetGetRadioVal, (XtPointer) rPtr);
  142.  
  143.   for (vptr = set_value; vptr->name != NULL; vptr++)
  144.     SeAddButtonWCD(vptr->name, uBox, SetGetValue, (XtPointer) vptr);
  145.  
  146.   SeAddButtonWCD("dismiss", lBox, DestroyShellCallBack, (XtPointer) mBox);
  147.  
  148.   XtPopup(popup, XtGrabExclusive);
  149. }
  150.  
  151. void
  152. SetGetRadioVal(widget, client_data)
  153.      Widget          widget;
  154.      XtPointer       client_data;
  155. {
  156.   struct _setRadio *rPtr = (struct _setRadio*)client_data;
  157.  
  158.   rPtr->activeIndex = (*rPtr->call_back)(-1);
  159.   SePopupRadio(rPtr->name, widget, rPtr->button, rPtr->activeIndex,
  160.                SetDoGetRadioVal, (XtPointer)rPtr);
  161. }
  162.  
  163. void
  164. SetDoGetRadioVal(widget, client_data)
  165.      Widget          widget;
  166.      XtPointer       client_data;
  167. {
  168.   int   TerminalRefreshParameters();
  169.  
  170.   struct _setRadio *rPtr = (struct _setRadio *)client_data;
  171.   Boolean         state;
  172.  
  173.   XtVaGetValues(widget, XtNradioData, &(rPtr->activeIndex), XtNstate,
  174.         &state, NULL);
  175.  
  176.   /* The callback routine is called both when the widget is set or unset,
  177.      so we make sure we do nothing if the widget is unset */
  178.   if (state == False)
  179.     return;
  180.  
  181.   (void)(*rPtr->call_back) (rPtr->activeIndex);
  182.   TerminalRefreshParameters();
  183.   SeyonMessage("Parameter Change Performed");
  184. }
  185.  
  186. void
  187. SetGetValue(widget, client_data)
  188.      Widget          widget;
  189.      XtPointer       client_data;
  190. {
  191.   struct _setValue *vptr;
  192.  
  193.   vptr = set_value;
  194.   strcpy(vptr->value, modem_port);
  195.   vptr++;
  196.  
  197.   curValObjPtr = (vptr = (struct _setValue *)client_data);
  198.   SePopupDialogGetStringE("set_value", widget, SetDoGetValue,
  199.               client_data, vptr->value, True);
  200. }
  201.  
  202. void
  203. SetDoGetValue(widget, client_data)
  204.      Widget          widget;
  205.      XtPointer       client_data;
  206. {
  207.   int   TerminalRefreshParameters();
  208.  
  209.   Widget          dialog = XtParent(widget);
  210.   struct _setValue *vptr = (struct _setValue *)client_data;
  211.  
  212.   str_stripspc_copy(vptr->value, XawDialogGetValueString(dialog));
  213.   DestroyShell(dialog);
  214.   (void)(*vptr->call_back) (vptr->value);
  215.   RestartTerminal();
  216.   SeyonMessage("Parameter Change Performed");
  217. }
  218.  
  219. void
  220. setVal_action_ok(widget)
  221.      Widget          widget;
  222. {
  223.   SetDoGetValue(widget, (XtPointer) curValObjPtr);
  224. }
  225.  
  226. void
  227. UpdateToggleSettings(widget, clientData)
  228.      Widget          widget;
  229.      XtPointer       clientData;
  230. {
  231.   int   TerminalRefreshParameters();
  232.  
  233.   /* We have to complicate things a bit to avoid the danger of the case
  234.      SeGetTog.. = True = -1. One should not assume True = 1*/
  235.   ((void (*)())clientData)(SeGetToggleState(widget) ? 1 : 0);
  236.   TerminalRefreshParameters();
  237.   SeyonMessage("Parameter Change Performed");
  238. }
  239.  
  240. int
  241. SetIStrip(state)
  242.      int state;
  243. {
  244.   qres.stripHighBit = (Boolean)state;
  245.   return MdmSetGetIStrip(state);
  246. }
  247.  
  248. int
  249. ToggleDelMode()
  250. {
  251.   toggle_flag(&(qres.backspaceTranslation));
  252.   return 0;
  253. }
  254.  
  255. int
  256. ToggleMetaKeyTr()
  257. {
  258.   toggle_flag(&(qres.metaKeyTranslation));
  259.   return 0;
  260. }
  261.  
  262. int
  263. ToggleXOffMode()
  264. {
  265.   toggle_flag(&(qres.xonxoffFlowControl));
  266.   xc_setflow();
  267.   return 0;
  268. }
  269.  
  270. int
  271. ToggleRtsctsMode()
  272. {
  273.   toggle_flag(&(qres.rtsctsFlowControl));
  274.   set_rtscts();
  275.   return 0;
  276. }
  277.  
  278. int
  279. ToggleZmodemAutoDownload()
  280. {
  281.   toggle_flag(&(qres.autoZmodem));
  282.   return 0;
  283. }
  284.  
  285. int
  286. ToggleIdleGuard()
  287. {
  288.   toggle_flag(&(qres.idleGuard));
  289.   IdleGuard();
  290.   return 0;
  291. }
  292.  
  293. int
  294. DetNewlineTrMode(keyword)
  295.      String          keyword;
  296. {
  297.   char            kw[SM_BUF];
  298.  
  299.   if ((keyword == NULL) || (*keyword == '\0')) {
  300.     SeError("missing newlineTranslation keyword");
  301.     return -1;
  302.   }
  303.  
  304.   str_stripspc_copy(kw, keyword);
  305.   lc_word(kw);
  306.   if (strcmp(kw, "nl") == 0)
  307.     return 1;
  308.   else if (strcmp(kw, "cr") == 0)
  309.     return 2;
  310.   else if (strcmp(kw, "cr/lf") == 0)
  311.     return 3;
  312.   else {
  313.     SeErrorF("illigal newlineTranslation keyword: %s", keyword, "", "");
  314.     return -1;
  315.   }
  316. }
  317.  
  318. void
  319. SetNewlineTrMode(keyword)
  320.      String          keyword;
  321. {
  322.   if ((newlineTrMode = DetNewlineTrMode(keyword)) < 0)
  323.     newlineTrMode = 2;
  324. }
  325.  
  326. int
  327. MenuSetGetNewlineTrMode(trMode)
  328.      int             trMode;
  329. {
  330.   if (trMode != -1)
  331.     newlineTrMode = trMode;
  332.   return newlineTrMode;
  333. }
  334.  
  335. void
  336. SetScrNewlineTrMode()
  337. {
  338.   getword();
  339.   if (word[0] == '\0') {
  340.     SeError("'set newlineTranslation' must specify translation mode");
  341.     eof_flag++;
  342.     return;
  343.   }
  344.  
  345.   SetNewlineTrMode(word);
  346. }
  347.  
  348. int
  349. MenuSetGetBaud(baudIndex)
  350.      int             baudIndex;
  351. {
  352.   return MdmSetGetBaud(baudIndex);
  353. }
  354.  
  355. int
  356. MenuSetGetCSize(bitsIndex)
  357.      int             bitsIndex;
  358. {
  359.   return MdmSetGetCSize(bitsIndex == -1 ? bitsIndex :
  360.             bitsIndex + 4) - 4;
  361. }
  362.  
  363. int
  364. MenuSetGetParity(parityIndex)
  365.      int             parityIndex;
  366. {
  367.   return MdmSetGetParity(parityIndex == -1 ? parityIndex :
  368.              parityIndex - 1) + 1;
  369. }
  370.  
  371. int
  372. MenuSetGetStopBits(bitsIndex)
  373.      int             bitsIndex;
  374. {
  375.   return MdmSetGetStopBits(bitsIndex);
  376. }
  377.  
  378. int
  379. MenuSetGetParamSCut(paramIndex)
  380.      int             paramIndex;
  381. {
  382.   int             bits,
  383.                   parity,
  384.                   stopBits;
  385.  
  386.   if (paramIndex == -1) {
  387.  
  388.     bits = MdmSetGetCSize(-1);
  389.     parity = MdmSetGetParity(-1);
  390.     stopBits = MdmSetGetStopBits(-1);
  391.  
  392.     if (bits == 8 && parity == 0 && stopBits == 1)
  393.       return 1;
  394.     else if (bits == 7 && parity == 2 && stopBits == 1)
  395.       return 2;
  396.     else
  397.       return 3;
  398.   }
  399.  
  400.   if (paramIndex == 1) {
  401.     MdmSetGetCSize(8);
  402.     MdmSetGetParity(0);
  403.     MdmSetGetStopBits(1);
  404.   }
  405.   else if (paramIndex == 2) {
  406.     MdmSetGetCSize(7);
  407.     MdmSetGetParity(2);
  408.     MdmSetGetStopBits(1);
  409.   }
  410.  
  411.   return paramIndex;
  412. }
  413.  
  414. int
  415. SetBaud(baud)
  416.      String          baud;
  417. {
  418.   if (mbaud(baud) < 0) {
  419.     SeErrorF("unsupported baud rate %s", baud, "", "");
  420.     return False;
  421.   }
  422.   return True;
  423. }
  424.  
  425. int
  426. SetPort(port)
  427.      String          port;
  428. {
  429.   int             retStatus,
  430.                   reopRetStatus;
  431.   String          oldPort = XtNewString(mport(NULL));
  432.  
  433.   unlock_tty();
  434.   CloseModem();
  435.  
  436.   if ((retStatus = OpenModem(port)) < 0) {
  437.     ShowOpenModemErrMsg(port, retStatus);
  438.  
  439.     if ((reopRetStatus = OpenModem(oldPort)) < 0)
  440.       {ShowOpenModemErrMsg(oldPort, reopRetStatus);
  441.       SeError(FmtString("Could not re-open old modem device %s", oldPort, "", 
  442.                         ""));}
  443.   }
  444.  
  445.   XtFree(oldPort);
  446.   return retStatus;
  447. }
  448.  
  449. void            s_set_xoff(),
  450.                 s_set_baud(),
  451.                 set_port(),
  452.                 s_set_cr(),
  453.                 ScrSetIStrip(),
  454.                 s_set_del(),
  455.                 set_meta_tr(),
  456.                 s_set_rtscts(),
  457.                 s_set_autozm(),
  458.                 SetScrIdleGuardMode(),
  459.                 ScrSetCSize(),
  460.                 ScrSetParity(),
  461.                 ScrSetStopBits();
  462.  
  463. struct kw       setlist[] =
  464. {
  465.   {"stripHighBit", ScrSetIStrip},
  466.   {"bits", ScrSetCSize},
  467.   {"parity", ScrSetParity},
  468.   {"stopBits", ScrSetStopBits},
  469.   {"newlineTranslation", SetScrNewlineTrMode},
  470.   {"del", s_set_del},
  471.   {"meta_tr", set_meta_tr},
  472.   {"xoff", s_set_xoff},
  473.   {"rtscts", s_set_rtscts},
  474.   {"autozm", s_set_autozm},
  475.   {"idleGuard", SetScrIdleGuardMode},
  476.   {"baud", s_set_baud},
  477.   {"port", set_port},
  478.   {NULL, NULL}};
  479.  
  480. void
  481. s_set()
  482. {
  483.   struct kw      *ptr;
  484.  
  485.   GETTEST_ARG("set");
  486.  
  487. /*  lc_word(word);*/
  488.  
  489.   for (ptr = setlist; ptr->keyword != NULL; ptr++)
  490.     if (strcmp(ptr->keyword, word) == 0)
  491.       {(*ptr->rtn)(); return;}
  492.  
  493.   SeErrorF("Invalid set keyword `%s'", word, "", "");
  494.   eof_flag++;
  495. }
  496.  
  497. void
  498. s_set_cr()
  499. {
  500.   set_onoff(&(qres.newlineTranslation));
  501. }
  502.  
  503. void
  504. ScrSetIStrip()
  505. {
  506.   Boolean tmpSetFlag;
  507.  
  508.   set_onoff(&tmpSetFlag);
  509.   SetIStrip(tmpSetFlag ? 1 : 0);
  510. }
  511.  
  512. void
  513. s_set_del()
  514. {
  515.   set_onoff(&(qres.backspaceTranslation));
  516. }
  517.  
  518. void
  519. set_meta_tr()
  520. {
  521.   set_onoff(&(qres.metaKeyTranslation));
  522. }
  523.  
  524. void
  525. s_set_xoff()
  526. {
  527.   set_onoff(&(qres.xonxoffFlowControl));
  528.   xc_setflow();
  529. }
  530.  
  531. void
  532. s_set_rtscts()
  533. {
  534.   set_onoff(&(qres.rtsctsFlowControl));
  535.   set_rtscts();
  536. }
  537.  
  538. void
  539. s_set_autozm()
  540. {
  541.   set_onoff(&(qres.autoZmodem));
  542. }
  543.  
  544. void
  545. SetScrIdleGuardMode()
  546. {
  547.   set_onoff(&(qres.idleGuard));
  548.   IdleGuard();
  549. }
  550.  
  551. void
  552. set_onoff(flag)
  553.      Boolean        *flag;
  554. {
  555.   String          keyWord = XtNewString(word);
  556.  
  557.   getword();
  558.   lc_word(word);
  559.  
  560.   if (strcmp(word, "on") == 0) *flag = True;
  561.   else if (strcmp(word, "off") == 0) *flag = False;
  562.   else {
  563.     SeErrorF("Argument `%s' to keyword `%s' is neither on nor off", 
  564.              word, keyWord, "");
  565.     eof_flag++;
  566.   }
  567.  
  568.   if (keyWord) XtFree(keyWord);
  569. }
  570.  
  571. #define ScrGetArg(msg) \
  572. { \
  573.   getword(); \
  574.   if (word[0] == '\0') { \
  575.     SeError(msg); \
  576.     eof_flag++; \
  577.     return; \
  578.   } \
  579. }
  580.  
  581. void
  582. ScrSetCSize()
  583. {
  584.   ScrGetArg("set bits: missing argument");
  585.   MdmSetGetCSize(atoi(word));
  586. }
  587.  
  588. void
  589. ScrSetParity()
  590. {
  591.   ScrGetArg("set parity: missing argument");
  592.   MdmSetGetParity(atoi(word));
  593. }
  594.  
  595. void
  596. ScrSetStopBits()
  597. {
  598.   ScrGetArg("set stopBits: missing argument");
  599.   MdmSetGetStopBits(atoi(word));
  600. }
  601.  
  602. void
  603. s_set_baud()
  604. {
  605.   getword();
  606.   if (word[0] == '\0') {
  607.     SeError("'set baud' must specify baud rate");
  608.     eof_flag++;
  609.     return;
  610.   }
  611.  
  612.   if (SetBaud(word) == False)
  613.     eof_flag++;
  614. }
  615.  
  616. void
  617. set_port()
  618. {
  619.   SeNotice("/sp/ Sorry, \"set port\" is not supported in this release");
  620.   return;
  621.  
  622.   getword();
  623.   if (word[0] == '\0') {
  624.     SeError("'set port' must specify modem device");
  625.     eof_flag++;
  626.     return;
  627.   }
  628.  
  629.   if (SetPort(word) == False)
  630.     eof_flag++;
  631. }
  632.  
  633. struct param {
  634.   Boolean         autoZmodem;
  635.   Boolean         idleGuard;
  636.   Boolean         stripHighBit;
  637.   Boolean         backspaceTranslation;
  638.   Boolean         metaKeyTranslation;
  639.   Boolean         xonxoffFlowControl;
  640.   Boolean         rtsctsFlowControl;
  641.   int             newlineTrMode;
  642.  
  643. };
  644.  
  645. int
  646. PutParameters(destination)
  647.      int *destination;
  648. {
  649.   struct param    param;
  650.   int             writeRetStatus;
  651.  
  652.   param.idleGuard = qres.idleGuard;
  653.   param.stripHighBit = qres.stripHighBit;
  654.   param.backspaceTranslation = qres.backspaceTranslation;
  655.   param.metaKeyTranslation = qres.metaKeyTranslation;
  656.   param.xonxoffFlowControl = qres.xonxoffFlowControl;
  657.   param.rtsctsFlowControl = qres.rtsctsFlowControl;
  658.   param.autoZmodem = qres.autoZmodem;
  659.   param.newlineTrMode = newlineTrMode;
  660.  
  661.   if ((writeRetStatus = write(destination[1], (char*)¶m, sizeof(param)))
  662.       == -1)
  663.     SePError("Could not write to pipe");
  664.   
  665.   return writeRetStatus;
  666. }
  667.  
  668. void
  669. GetParameters(clientData, source)
  670.      XtPointer  clientData;
  671.      int       *source;
  672. {
  673.   struct param    param;
  674.  
  675.   if (read(source[0], (char*)¶m, sizeof(param)) == -1)
  676.     SePError("Could not read from pipe");
  677.  
  678.   qres.idleGuard = param.idleGuard;
  679.   qres.stripHighBit = param.stripHighBit;
  680.   qres.backspaceTranslation = param.backspaceTranslation;
  681.   qres.metaKeyTranslation = param.metaKeyTranslation;
  682.   qres.xonxoffFlowControl = param.xonxoffFlowControl;
  683.   qres.rtsctsFlowControl = param.rtsctsFlowControl;
  684.   qres.autoZmodem = param.autoZmodem;
  685.   newlineTrMode = param.newlineTrMode;
  686.  
  687.   get_modem_attr();
  688. }
  689.